Non-stroboscopic non-emissive displays, such as Liquid Crystal Displays (LCD), active-matrix LCDs (amLCD), Plasma Panel Displays (PDP), Thin Film Transistor (TFT) displays, Liquid Crystal on Silicon (LCOS) displays or Colour Sequential Displays, consist of a display panel having a row and column array of image elements (pixels) for modulating light, means for illuminating the display panel from the front or back side, and drive means for driving the pixels in accordance with an applied input video signal. Quite similar, non-stroboscopic emissive displays, such as Organic Light Emitting Diodes (O-LED) displays, Polymer Light Emitting Diodes (PLED) displays, active-matrix PLEDs (amPLED) displays or Plasma Display Panels (PDP), consist of a display panel having a row and column array of pixels (LEDs) and drive means for driving the pixels (LEDs) in accordance with an applied input video signal. However, the pixels (LEDs) emit and modulate light by themselves without requiring illumination from the front or back side.
In state-of-the-art Cathode Ray Tubes (CRTs), each pixel of a displayed image is generated as a pulse, which is very short compared to the image period T. Different to these state-of-the-art CRTs, in new flat, high quality, low cost non-stroboscopic display devices, each pixel is displayed during most of the image period. Of course, this non-stroboscopic behavior also holds for types of CRTs whose pixels, e.g. slow phosphor atoms, are active for a time not negligible to the image period. In the sequel of this description, we thus will only differentiate between stroboscopic and non-stroboscopic displays, and in case of a non-stroboscopic display, we will use the term “pixel” for both the elements of a light modulation/generation array and the activated (slow) atoms of a CRT-type display.
In case any area of the image displayed on a non-stroboscopic display contains motion, the viewer will track this motion. As each pixel is displayed substantially the whole image period, the intensity of pixels showing the motion is integrated along the motion trajectory as follows:
                                          F            out                    ⁡                      (                                          x                ->                            ,              n                        )                          =                              1                          t              i                                ⁢                                    ∫              0                              t                i                                      ⁢                                          F                ⁡                                  (                                                                                    x                        ->                                            +                                                                        t                          T                                                ⁢                                                  D                          ->                                                                                      ,                    n                                    )                                            ⁢                              ⅆ                t                                                                        (        1        )            with ti as display time of each image, F as input video signal, Fout as output video signal, and T as image period. The motion vector {right arrow over (D)}={right arrow over (v)}T is the product of the object velocity {right arrow over (v)} and the image period T. In case ti is constant, the integration is the same as a convolution of F({right arrow over (x)}, n) and a sample-and-hold function h(α):
                                                                                          F                  out                                ⁡                                  (                                                            x                      ->                                        ,                    n                                    )                                            =                            ⁢                                                T                                      t                    i                                                  ⁢                                                      ∫                    0                                                                  t                        i                                            T                                                        ⁢                                                            F                      ⁡                                              (                                                                                                            x                              ->                                                        +                                                          α                              ⁢                                                                                                                          ⁢                                                              D                                ->                                                                                                              ,                          n                                                )                                                              ⁢                                          ⅆ                      α                                                                                                                                              =                            ⁢                                                ∫                                      -                    ∞                                    ∞                                ⁢                                                                            F                      ⁡                                              (                                                                                                            x                              ->                                                        +                                                          α                              ⁢                                                                                                                          ⁢                                                              D                                ->                                                                                                              ,                          n                                                )                                                              ·                                          h                      ⁡                                              (                        α                        )                                                                              ⁢                                      ⅆ                    α                                                                                                          (        2        )            where
                              h          ⁡                      (            α            )                          =                  {                                                                                          T                    /                                          t                      i                                                        ,                                      0                    ≤                    α                    ≤                                                                  t                        i                                            /                      T                                                                                                                                            0                  ,                  otherwise                                                                                        (        3        )            is a 1D block function, oriented along the motion vector {right arrow over (D)}. It is therefore actually a 2D function h({right arrow over (x)}), which has zero value outside the line segment {right arrow over (x)}=k{right arrow over (D)}, 0≦k≦ti/T, while the 2D integral area is normalized to 1. The 2D spatial Fourier transform (leading to a representation of h({right arrow over (x)}) in the spatial frequency domain) of Eq. (2) yields:
                                                                                          F                  out                                (                                                      f                    ->                                    ,                  n                                )                            =                            ⁢                                                ∫                                      -                    ∞                                    ∞                                ⁢                                                      ∫                                          -                      ∞                                        ∞                                    ⁢                                                                                    F                        out                                            (                                                                        x                          ->                                                ,                        n                                            )                                        ⁢                                          ⅇ                                              (                                                                              -                            j                                                    ⁢                                                                                                          ⁢                          2                          ⁢                                                                                                          ⁢                          π                          ⁢                                                                                                          ⁢                                                      x                            ->                                                    ⁢                                                      f                            ->                                                                          )                                                              ⁢                                          ⅆ                                              x                        ->                                                                                                                                                                    =                            ⁢                                                F                  (                                                            f                      ->                                        ,                    n                                    )                                ·                                  H                  (                                      f                    ->                                    )                                                                                        (        4        )            with F({right arrow over (f)}, n) denoting the 2D spatial Fourier transform of the input video signal F({right arrow over (x)}, n), and H({right arrow over (f)}) denoting the 2D spatial Fourier transform of h({right arrow over (x)}):
                              H          (                      f            ->                    )                =                                            sin              ⁡                              (                                  π                  ⁢                                                                          ⁢                                      D                    ->                                    ⁢                                                                                                                                ⁢                                              t                        i                                                              T                                    ⁢                                      f                    ->                                                  )                                                    π              ⁢                                                          ⁢                              D                ->                            ⁢                                                          ⁢                                                t                  i                                T                            ⁢                              f                ->                                              =                      sin            ⁢                                                  ⁢                                          c                (                                  π                  ⁢                                                                          ⁢                                      D                    ->                                    ⁢                                                                          ⁢                                                            t                      i                                        T                                    ⁢                                      f                    ->                                                  )                            .                                                          (        5        )            
Apparently the effect of the motion tracking/temporal sample-and-hold characteristic is a spatial frequency low-pass filtering in the direction of the motion with a sinc-frequency response, with a cut-off-frequency being inversely proportional to the quantity
                    t        i            T        ⁢          D      ->        ,where
      t    i    Tis denoted as the duty cycle of the display. The non-stroboscopic light generation, combined with the eye tracking of the viewer trying to follow moving objects from one image to the next, thus leads to the perception of motion-dependent blur in the images. When the motion {right arrow over (D)} in the image increases, the cut-off-frequency of the spatial low pass filter and thus the degree of perceived motion blur can be kept constant by reducing the display time
      t    i    ⁡      (          or      ⁢                          ⁢      the      ⁢                          ⁢      duty      ⁢                          ⁢      cycle      ⁢                          ⁢                        t          i                T              )  with the drawback of loss of brightness and increased flicker.
To reduce motion blur, loss of brightness and flicker, prior art document WO 03/101086 A2 proposes to measure the motion and the characteristics of motion in the images of the input video signal and to continuously adjust the display time ti depending on this measured motion and the characteristics of motion. In a preferred embodiment, additionally anti-motion blur filtering based on the measured motion vectors is performed, and the display time and the sort and amount of anti-motion blur filtering are jointly controlled based on the measured motion and the characteristics of motion. In a further preferred embodiment, local image characteristics that determine high spatial frequencies are considered in the filtering process and in the joint control of display time and sort and amount of anti-motion blur filtering, because these characteristics contain information on how reliable anti-motion blur filtering can be performed. To reduce loss of brightness, WO 03/101086 A2 proposes to control the light output of the display inversely proportional to the display time, and, to reduce flicker, it is targeted to keep the display time as large as possible and to suppress motion blur with anti-motion blur filtering instead of reducing the display time.
All embodiments of WO 03/101086 A2 require the estimation of both the amount and the direction of motion vectors and thus require frame memories and computationally expensive real-time motion estimation algorithms. This proposed display system is thus complex and expensive when being implemented.